home *** CD-ROM | disk | FTP | other *** search
/ Enter 2004 January / enter-2004-01.iso / files / maxima-5.9.0.exe / {app} / share / maxima / 5.9.0 / src / comm2.lisp < prev    next >
Encoding:
Text File  |  2003-02-09  |  31.2 KB  |  931 lines
  1. ;;; -*-  Mode: Lisp; Package: Maxima; Syntax: Common-Lisp; Base: 10 -*- ;;;;
  2. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  3. ;;;     The data in this file contains enhancments.                    ;;;;;
  4. ;;;                                                                    ;;;;;
  5. ;;;  Copyright (c) 1984,1987 by William Schelter,University of Texas   ;;;;;
  6. ;;;     All rights reserved                                            ;;;;;
  7. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  8.  
  9. (in-package "MAXIMA")
  10. ;    ** (c) Copyright 1982 Massachusetts Institute of Technology **
  11.  
  12. (macsyma-module comm2)
  13.  
  14. ;;;; DIFF2
  15.  
  16. (DECLARE-TOP (GENPREFIX CC) (SPECIAL $PROPS) (FIXNUM N I J))
  17.  
  18. (DECLARE-TOP ;(SPLITFILE DIFF2)
  19.      (SPECIAL $DOTDISTRIB))
  20.  
  21. (DEFMFUN DIFFINT (E X)
  22.   (LET (A)
  23.     (COND ((NULL (CDDDR E))
  24.        (COND ((ALIKE1 X (CADDR E)) (CADR E))
  25.          ((AND (NOT (ATOM (CADDR E))) (ATOM X) (NOT (FREE (CADDR E) X)))
  26.           (MUL2 (CADR E) (SDIFF (CADDR E) X)))
  27.          ((OR ($CONSTANTP (SETQ A (SDIFF (CADR E) X)))
  28.               (AND (ATOM (CADDR E)) (FREE A (CADDR E))))
  29.           (MUL2 A (CADDR E)))
  30.          (T (SIMPLIFYA (LIST '(%INTEGRATE) A (CADDR E)) T))))
  31.       ((ALIKE1 X (CADDR E)) (ADDN (DIFFINT1 (CDR E) X X) T))
  32.       (T (ADDN (CONS (IF (EQUAL (SETQ A (SDIFF (CADR E) X)) 0)
  33.                  0
  34.                  (SIMPLIFYA (LIST '(%INTEGRATE) A (CADDR E)
  35.                           (CADDDR E) (CAR (CDDDDR E)))
  36.                     T))
  37.              (DIFFINT1 (CDR E) X (CADDR E)))
  38.            T)))))
  39.  
  40. (DEFUN DIFFINT1 (E X Y)
  41.   (LET ((U (SDIFF (CADDDR E) X)) (V (SDIFF (CADDR E) X)))
  42.     (LIST (IF (pZEROP U) 0 (MUL2 U (MAXIMA-SUBSTITUTE (CADDDR E) Y (CAR E))))
  43.       (IF (pZEROP V) 0 (MUL3 V (MAXIMA-SUBSTITUTE (CADDR E) Y (CAR E)) -1)))))
  44.  
  45. (DEFMFUN DIFFSUMPROD (E X)
  46.   (COND ((OR (NOT (ATOM X)) (NOT (FREE (CADDDR E) X)) (NOT (FREE (CAR (CDDDDR E)) X)))
  47.      (DIFF%DERIV (LIST E X 1)))
  48.     ((EQ (CADDR E) X) 0)
  49.     (T (LET ((U (SDIFF (CADR E) X)))
  50.          (SETQ U (SIMPLIFYA (LIST '(%SUM)
  51.                       (IF (EQ (CAAR E) '%SUM) U (DIV U (CADR E)))
  52.                       (CADDR E) (CADDDR E) (CAR (CDDDDR E)))
  53.               T))
  54.     (IF (EQ (CAAR E) '%SUM) U (MUL2 E U))))))
  55.  
  56. (DEFMFUN DIFFLAPLACE (E X)
  57.   (COND ((OR (NOT (ATOM X)) (EQ (CADDDR E) X)) (DIFF%DERIV (LIST E X 1)))
  58.     ((EQ (CADDR E) X) 0)
  59.     (T ($LAPLACE (SDIFF (CADR E) X) (CADDR E) (CADDDR E)))))
  60.  
  61. (DEFMFUN DIFF-%AT (E X)
  62.   (COND ((FREEOF X E) 0)
  63.     ((NOT (FREEOFL X (HAND-SIDE (CADDR E) 'R))) (DIFF%DERIV (LIST E X 1)))
  64.     (T ($AT (SDIFF (CADR E) X) (CADDR E)))))
  65.  
  66. (DEFMFUN DIFFNCEXPT (E X)
  67.  ((LAMBDA (BASE* POW)
  68.    (COND ((AND (MNUMP POW) (OR (NOT (EQ (ml-typep POW) 'fixnum)) (< POW 0)))  ; POW cannot be 0
  69.       (DIFF%DERIV (LIST E X 1)))
  70.      ((AND (ATOM BASE*) (EQ BASE* X) (FREE POW BASE*))
  71.       (MUL2* POW (LIST '(MNCEXPT) BASE* (ADD2 POW -1))))
  72.      ((ml-typep POW 'fixnum)
  73.       ((LAMBDA (DERIV ANS)
  74.         (DO ((I 0 (f1+ I))) ((= I POW))
  75.         (SETQ ANS (CONS (LIST '(MNCTIMES) (LIST '(MNCEXPT) BASE* I)
  76.                       (LIST '(MNCTIMES) DERIV
  77.                         (LIST '(MNCEXPT) BASE* (f- POW 1 I))))
  78.                 ANS)))
  79.         (ADDN ANS NIL))
  80.        (SDIFF BASE* X) NIL))
  81.      ((AND (NOT (DEPENDS POW X)) (OR (ATOM POW) (AND (ATOM BASE*) (FREE POW BASE*))))
  82.       ((LAMBDA (DERIV INDEX)
  83.         (SIMPLIFYA
  84.          (LIST '(%SUM)
  85.            (LIST '(MNCTIMES) (LIST '(MNCEXPT) BASE* INDEX)
  86.              (LIST '(MNCTIMES) DERIV
  87.                    (LIST '(MNCEXPT) BASE* 
  88.                      (LIST '(MPLUS) POW -1 (LIST '(MTIMES) -1 INDEX)))))
  89.            INDEX 0 (LIST '(MPLUS) POW -1)) NIL))
  90.        (SDIFF BASE* X) (GENSUMINDEX)))
  91.      (T (DIFF%DERIV (LIST E X 1)))))
  92.   (CADR E) (CADDR E)))
  93.  
  94. (DEFMFUN STOTALDIFF (E)
  95.  (COND ((OR (MNUMP E) (CONSTANT E)) 0)
  96.        ((OR (ATOM E) (MEMQ 'array (CDAR E)))
  97.     (LET ((W (MGET (IF (ATOM E) E (CAAR E)) 'DEPENDS)))
  98.          (IF W (CONS '(MPLUS)
  99.              (MAPCAR #'(LAMBDA (X)
  100.                     (LIST '(MTIMES) (CHAINRULE E X) (LIST '(%DEL) X)))
  101.                  W))
  102.            (LIST '(%DEL) E))))
  103.        ((SPECREPP E) (STOTALDIFF (SPECDISREP E)))
  104.        ((EQ (CAAR E) 'MNCTIMES)
  105.     (LET (($DOTDISTRIB T))
  106.          (ADD2 (NCMULN (CONS (STOTALDIFF (CADR E)) (CDDR E)) T)
  107.            (NCMUL2 (CADR E) (STOTALDIFF (NCMULN (CDDR E) T))))))
  108.        ((EQ (CAAR E) 'MNCEXPT)
  109.     (IF (AND (ml-typep (CADDR E) 'fixnum) (> (CADDR E) 0))
  110.         (STOTALDIFF (LIST '(MNCTIMES) (CADR E)
  111.                   (NCPOWER (CADR E) (f1- (CADDR E)))))
  112.         (LIST '(%DERIVATIVE) E)))
  113.        (T (ADDN (CONS 0 (MAPCAR #'(LAMBDA (X)
  114.                    (MUL2 (SDIFF E X) (LIST '(%DEL SIMP) X)))
  115.                 (EXTRACTVARS (MARGS E))))
  116.         T))))
  117.  
  118. (DEFUN EXTRACTVARS (E)
  119.        (COND ((NULL E) NIL)
  120.          ((ATOM (CAR E))
  121.           (IF (NOT (MAXIMA-CONSTANTP (CAR E)))
  122.           (UNION* (NCONS (CAR E)) (EXTRACTVARS (CDR E)))
  123.           (EXTRACTVARS (CDR E))))
  124.          ((MEMQ 'array (CDAAR E)) (UNION* (NCONS (CAR E)) (EXTRACTVARS (CDR E))))
  125.          (T (UNION* (EXTRACTVARS (CDAR E)) (EXTRACTVARS (CDR E))))))
  126.  
  127.  
  128. ;;;; AT
  129.  
  130. ;dummy-variable-operators is defined in COMM, which uses it inside of SUBST1.
  131. (DECLARE-TOP #-NIL (SPLITFILE AT)
  132.      (SPECIAL ATVARS ATEQS ATP MUNBOUND DUMMY-VARIABLE-OPERATORS)
  133.      #-cl
  134.      (*LEXPR $SUBSTITUTE))
  135.  
  136. (DEFMFUN $ATVALUE (EXP EQS VAL) 
  137.  (LET (DL VL FUN)
  138.       (COND ((NOTLOREQ EQS) (IMPROPER-ARG-ERR EQS '$ATVALUE))
  139.         ((OR (ATOM EXP) (AND (EQ (CAAR EXP) '%DERIVATIVE) (ATOM (CADR EXP))))
  140.          (IMPROPER-ARG-ERR EXP '$ATVALUE)))
  141.       (COND ((NOT (EQ (CAAR EXP) '%DERIVATIVE))
  142.          (SETQ FUN (CAAR EXP) VL (CDR EXP) DL (LISTOF0S VL)))
  143.         (T (SETQ FUN (CAAADR EXP) VL (CDADR EXP))
  144.            (DOLIST (V VL)
  145.                (SETQ DL (NCONC DL (NCONS (OR (GETf (CDdR EXP) V) 0)))))))
  146.       (IF (OR (MOPP FUN) (EQ FUN 'MQAPPLY)) (IMPROPER-ARG-ERR EXP '$ATVALUE))
  147.       (ATVARSCHK VL)
  148.       (DO ((VL1 VL (CDR VL1)) (L ATVARS (CDR L))) ((NULL VL1))
  149.       (IF (AND (SYMBOLP (CAR VL1)) (NOT (MGET (CAR VL1) '$CONSTANT)))
  150.           (SETQ VAL (MAXIMA-SUBSTITUTE (CAR L) (CAR VL1) VAL))
  151.           (IMPROPER-ARG-ERR (CONS '(MLIST) VL) '$ATVALUE)))
  152.       (SETQ EQS (IF (EQ (CAAR EQS) 'MEQUAL) (LIST EQS) (CDR EQS)))
  153.       (SETQ EQS (DO ((EQS EQS (CDR EQS)) (L)) ((NULL EQS) L)
  154.             (IF (NOT (MEMQ (CADAR EQS) VL))
  155.             (IMPROPER-ARG-ERR (CAR EQS) '$ATVALUE))
  156.             (SETQ L (NCONC L (NCONS (CONS (CADAR EQS) (CADDAR EQS)))))))
  157.       (SETQ VL (DO ((VL VL (CDR VL)) (L)) ((NULL VL) L)
  158.            (SETQ L (NCONC L (NCONS (CDR (OR (ASSQ (CAR VL) EQS)
  159.                             (CONS NIL MUNBOUND))))))))
  160.       (DO ((ATVALUES (MGET FUN 'ATVALUES) (CDR ATVALUES)))
  161.       ((NULL ATVALUES)
  162.        (MPUTPROP FUN (CONS (LIST DL VL VAL) (MGET FUN 'ATVALUES)) 'ATVALUES))
  163.       (WHEN (AND (EQUAL (CAAR ATVALUES) DL) (EQUAL (CADAR ATVALUES) VL))
  164.         (RPLACA (CDDAR ATVALUES) VAL) (RETURN NIL)))
  165.       (ADD2LNC FUN $PROPS)
  166.       VAL))
  167.  
  168. (DEFMFUN $AT (EXP ATEQS)
  169.  (IF (NOTLOREQ ATEQS) (IMPROPER-ARG-ERR ATEQS '$AT))
  170.  (ATSCAN (LET ((ATP T)) ($SUBSTITUTE ATEQS EXP))))
  171.  
  172. (DEFUN ATSCAN (EXP)
  173.  (COND ((OR (ATOM EXP) (MEMQ (CAAR EXP) '(%AT MRAT))) EXP)
  174.        ((EQ (CAAR EXP) '%DERIVATIVE)
  175.     (OR (AND (NOT (ATOM (CADR EXP)))
  176.          (LET ((VL (CDADR EXP)) DL)
  177.               (DOLIST (V VL)
  178.                       (SETQ DL (NCONC DL (NCONS (OR (GETf (CdDR EXP) V)
  179.                                 0)))))
  180.               (ATFIND (CAAADR EXP)
  181.                   (CDR ($SUBSTITUTE ATEQS (CONS '(MLIST) VL)))
  182.                   DL)))
  183.         (LIST '(%AT) EXP ATEQS)))
  184.        ((MEMQ (CAAR EXP) DUMMY-VARIABLE-OPERATORS) (LIST '(%AT) EXP ATEQS))
  185.        ((AT1 EXP))
  186.        (T (RECUR-APPLY #'ATSCAN EXP))))
  187.  
  188. (DEFUN AT1 (EXP) (ATFIND (CAAR EXP) (CDR EXP) (LISTOF0S (CDR EXP))))
  189.  
  190. (DEFUN ATFIND (FUN VL DL)
  191.        (DO ((ATVALUES (MGET FUN 'ATVALUES) (CDR ATVALUES))) ((NULL ATVALUES))
  192.        (AND (EQUAL (CAAR ATVALUES) DL)
  193.         (DO ((L (CADAR ATVALUES) (CDR L)) (VL VL (CDR VL)))
  194.             ((NULL L) T)
  195.             (IF (AND (NOT (EQUAL (CAR L) (CAR VL)))
  196.                  (NOT (EQ (CAR L) MUNBOUND)))
  197.             (RETURN NIL)))
  198.         (RETURN (PROG2 (ATVARSCHK VL)
  199.                    (SUBSTITUTEL VL ATVARS (CADDAR ATVALUES)))))))
  200.  
  201. (DEFUN LISTOF0S (LLIST)
  202.   (DO ((LLIST LLIST (CDR LLIST)) (L NIL (CONS 0 L))) ((NULL LLIST) L)))
  203.  
  204. (declare-top (SPLITFILE LOGCON) (SPECIAL $RATFAC GENVAR VARLIST $KEEPFLOAT *E*))
  205.  
  206.  
  207. (DEFMVAR $LOGCONCOEFFP NIL)
  208. (DEFMVAR SUPERLOGCON T)
  209. (defmvar $superlogcon t)
  210.  
  211. (DEFMFUN $LOGCONTRACT (E) (LGCCHECK (LOGCON E)))  ; E is assumed to be simplified.
  212.  
  213. (DEFUN LOGCON (E)
  214.  (COND ((ATOM E) E)
  215.        ((MEMQ (CAAR E) '(MPLUS MTIMES))
  216.     (IF (AND $SUPERLOGCON (NOT (LGCSIMPLEP E))) (SETQ E (LGCSORT E)))
  217.     (COND ((MPLUSP E) (LGCPLUS E)) ((MTIMESP E) (LGCTIMES E)) (T (LOGCON E))))
  218.        (T (RECUR-APPLY #'LOGCON E))))
  219.  
  220. (DEFUN LGCPLUS (E)
  221.  (DO ((X (CDR E) (CDR X)) (LOG) (NOTLOGS) (Y))
  222.      ((NULL X)
  223.       (COND ((NULL LOG) (SUBST0 (CONS '(MPLUS) (NREVERSE NOTLOGS)) E))
  224.         (T (SETQ LOG (SRATSIMP (MULN LOG T)))
  225.            (ADDN (CONS (LGCSIMP LOG) NOTLOGS) T))))
  226.      (COND ((ATOM (CAR X)) (SETQ NOTLOGS (CONS (CAR X) NOTLOGS)))
  227.        ((EQ (CAAAR X) '%LOG) (SETQ LOG (CONS (LOGCON (CADAR X)) LOG)))
  228.        ((EQ (CAAAR X) 'MTIMES)
  229.         (SETQ Y (LGCTIMES (CAR X)))
  230.         (COND ((OR (ATOM Y) (NOT (EQ (CAAR Y) '%LOG)))
  231.            (SETQ NOTLOGS (CONS Y NOTLOGS)))
  232.           (T (SETQ LOG (CONS (CADR Y) LOG)))))
  233.        (T (SETQ NOTLOGS (CONS (LOGCON (CAR X)) NOTLOGS))))))
  234.  
  235. (DEFUN LGCTIMES (E)
  236.  (SETQ E (SUBST0 (CONS '(MTIMES) (MAPCAR 'LOGCON (CDR E))) E))
  237.  (COND ((NOT (MTIMESP E)) E)
  238.        (T (DO ((X (CDR E) (CDR X)) (LOG) (NOTLOGS) (DECINTS))
  239.           ((NULL X)
  240.            (COND ((OR (NULL LOG) (NULL DECINTS)) E)
  241.              (T (MULN (CONS (LGCSIMP (POWER LOG (MULN DECINTS T)))
  242.                     NOTLOGS)
  243.                   T))))
  244.           (COND ((AND (NULL LOG) (NOT (ATOM (CAR X)))
  245.               (EQ (CAAAR X) '%LOG) (NOT (EQUAL (CADAR X) -1)))
  246.              (SETQ LOG (CADAR X)))
  247.             ((LOGCONCOEFFP (CAR X)) (SETQ DECINTS (CONS (CAR X) DECINTS)))
  248.             (T (SETQ NOTLOGS (CONS (CAR X) NOTLOGS))))))))
  249.  
  250. (DEFUN LGCSIMP (E)
  251.  (COND ((ATOM E) (SIMPLN (LIST '(%LOG) E) 1 T)) (T (LIST '(%LOG SIMP) E))))
  252.  
  253. (DEFUN LGCSIMPLEP (E)
  254.  (AND (EQ (CAAR E) 'MPLUS)
  255.       (NOT (DO ((L (CDR E) (CDR L))) ((NULL L))
  256.            (COND ((NOT (OR (ATOM (CAR L))
  257.                    (NOT (ISINOP (CAR L) '%LOG))
  258.                    (EQ (CAAAR L) '%LOG)
  259.                    (AND (EQ (CAAAR L) 'MTIMES)
  260.                     (NULL (CDDDAR L))
  261.                     (MNUMP (CADAR L))
  262.                     (NOT (ATOM (CADDAR L)))
  263.                     (EQ (CAAR (CADDAR L)) '%LOG))))
  264.               (RETURN T)))))))
  265.  
  266. (DEFUN LGCSORT (E)
  267.  (LET (GENVAR VARLIST ($KEEPFLOAT T) VL E1)
  268.       (NEWVAR E)
  269.       (SETQ VL (DO ((VL VARLIST (CDR VL)) (LOGS) (NOTLOGS) (DECINTS))
  270.            ((NULL VL)
  271.             (SETQ LOGS (SORT LOGS #'GREAT))
  272.             (NRECONC DECINTS (NCONC LOGS (NREVERSE NOTLOGS))))
  273.            (COND ((AND (NOT (ATOM (CAR VL))) (EQ (CAAAR VL) '%LOG))
  274.               (SETQ LOGS (CONS (CAR VL) LOGS)))
  275.              ((LOGCONCOEFFP (CAR VL))
  276.               (SETQ DECINTS (CONS (CAR VL) DECINTS)))
  277.              (T (SETQ NOTLOGS (CONS (CAR VL) NOTLOGS))))))
  278.       (SETQ E1 (RATDISREP (RATREP E VL)))
  279.       (IF (ALIKE1 E E1) E E1)))
  280.  
  281. (DEFUN LGCCHECK (E)
  282.  (LET (NUM DENOM)
  283.       (COND ((ATOM E) E)
  284.         ((AND (EQ (CAAR E) '%LOG)
  285.           (SETQ NUM (zl-MEMBER ($NUM (CADR E)) '(1 -1)))
  286.           (NOT (EQUAL (SETQ DENOM ($DENOM (CADR E))) 1)))
  287.          (LIST '(MTIMES SIMP) -1
  288.            (LIST '(%LOG SIMP) (IF (= (CAR NUM) 1) DENOM (NEG DENOM)))))
  289.         (T (RECUR-APPLY #'LGCCHECK E)))))
  290.  
  291.  
  292. (DEFUN LOGCONCOEFFP (E)
  293.  (IF $LOGCONCOEFFP (LET ((*E* E)) (IS '(($LOGCONCOEFFP) *E*))) (MAXIMA-INTEGERP E)))
  294.  
  295.  
  296. ;;;; RTCON
  297.  
  298. (DECLARE-TOP #-NIL (SPLITFILE RTCON)
  299.      (SPECIAL $RADEXPAND $DOMAIN RADPE))
  300.  
  301. (DEFMVAR $ROOTSCONMODE T)
  302.  
  303. (DEFUN $ROOTSCONTRACT (E)  ; E is assumed to be simplified
  304.  ((LAMBDA (RADPE $RADEXPAND) (RTCON E))
  305.   (AND $RADEXPAND (NOT (EQ $RADEXPAND '$ALL)) (EQ $DOMAIN '$REAL)) NIL))
  306.  
  307. (DEFUN RTCON (E)
  308.  (COND ((ATOM E) E)
  309.        ((EQ (CAAR E) 'MTIMES)
  310.     (IF (AND (NOT (FREE E '$%I))
  311.          (LET ((NUM ($NUM E)))
  312.               (AND (NOT (ALIKE1 E NUM))
  313.                (OR (EQ NUM '$%I)
  314.                    (AND (NOT (ATOM NUM)) (MEMQ '$%I NUM)
  315.                     (MEMQ '$%I (RTCON NUM)))))))
  316.         (SETQ E (LIST* (CAR E) -1 '((MEXPT) -1 ((RAT SIMP) -1 2))
  317.                (DELQ '$%I (copy-top-level (CDR E)) 1))))
  318.     (DO ((X (CDR E) (CDR X)) (ROOTS) (NOTROOTS) (Y))
  319.         ((NULL X)
  320.          (COND ((NULL ROOTS) (SUBST0 (CONS '(MTIMES) (NREVERSE NOTROOTS)) E))
  321.            (T (IF $ROOTSCONMODE
  322.               (LET (((MIN GCD LCM) (RTC-GETINFO ROOTS)))
  323.                    (COND ((AND (= MIN GCD) (NOT (= GCD 1))
  324.                        (NOT (= MIN LCM))
  325.                        (NOT (EQ $ROOTSCONMODE '$ALL)))
  326.                       (SETQ ROOTS
  327.                         (RT-SEPAR
  328.                          (LIST GCD
  329.                            (RTCON
  330.                             (RTC-FIXITUP 
  331.                              (RTC-DIVIDE-BY-GCD ROOTS GCD)
  332.                              NIL))
  333.                            1)
  334.                          NIL)))
  335.                      ((EQ $ROOTSCONMODE '$ALL)
  336.                       (SETQ ROOTS
  337.                         (RT-SEPAR (SIMP-ROOTS LCM ROOTS)
  338.                               NIL))))))
  339.               (RTC-FIXITUP ROOTS NOTROOTS))))
  340.         (COND ((ATOM (CAR X))
  341.            (COND ((EQ (CAR X) '$%I) (SETQ ROOTS (RT-SEPAR (LIST 2 -1) ROOTS)))
  342.              (T (SETQ NOTROOTS (CONS (CAR X) NOTROOTS)))))
  343.           ((AND (EQ (CAAAR X) 'MEXPT) (RATNUMP (SETQ Y (CADDAR X))))
  344.            (SETQ ROOTS (RT-SEPAR (LIST (CADDR Y)
  345.                            (LIST '(MEXPT)
  346.                              (RTCON (CADAR X)) (CADR Y)))
  347.                      ROOTS)))
  348.  
  349.           ((AND RADPE (EQ (CAAAR X) 'MABS))
  350.            (SETQ ROOTS (RT-SEPAR (LIST 2 `((MEXPT) ,(RTCON (CADAR X)) 2) 1)
  351.                      ROOTS)))
  352.           (T (SETQ NOTROOTS (CONS (RTCON (CAR X)) NOTROOTS))))))
  353.        ((AND RADPE (EQ (CAAR E) 'MABS))
  354.     (POWER (POWER (RTCON (CADR E)) 2) '((RAT SIMP) 1 2)))
  355.        (T (RECUR-APPLY #'RTCON E))))
  356.  
  357. ; RT-SEPAR separates like roots into their appropriate "buckets", 
  358. ; where a bucket looks like:
  359. ; ((<denom of power> (<term to be raised> <numer of power>)
  360. ;             (<term> <numer>)) etc)
  361.  
  362. (DEFUN RT-SEPAR (A ROOTS)
  363.  (LET ((U (zl-ASSOC (CAR A) ROOTS)))
  364.       (COND (U (NCONC U (CDR A))) (T (SETQ ROOTS (CONS A ROOTS)))))
  365.  ROOTS)
  366.  
  367. (DEFUN SIMP-ROOTS (LCM ROOT-LIST)
  368.  (LET (ROOT1)
  369.       (DO ((X ROOT-LIST (CDR X)))
  370.       ((NULL X) (PUSH LCM ROOT1))
  371.       (PUSH (LIST '(MEXPT) (MULN (CDAR X) NIL) (QUOTIENT LCM (CAAR X)))
  372.         ROOT1))))
  373.  
  374. (DEFUN RTC-GETINFO (LLISt)
  375.  (LET ((M (CAAR LLIST)) (G (CAAR LLIST)) (L (CAAR LLIST)))
  376.       (DO ((X (CDR LLIST) (CDR X)))
  377.       ((NULL X) (LIST M G L))
  378.       (SETQ M (MIN M (CAAR X)) G (GCD G (CAAR X)) L (LCM L (CAAR X))))))
  379.  
  380. (DEFUN RTC-FIXITUP (ROOTS NOTROOTS)
  381.  (MAPCAR #'(LAMBDA (X) (RPLACD X (LIST (SRATSIMP (MULN (CDR X) (NOT $ROOTSCONMODE))))))
  382.      ROOTS)
  383.  (MULN (NCONC (MAPCAR #'(LAMBDA (X) (POWER* (CADR X) `((RAT) 1 ,(CAR X))))
  384.               ROOTS)
  385.           NOTROOTS)
  386.        (NOT $ROOTSCONMODE)))
  387.  
  388. (DEFUN RTC-DIVIDE-BY-GCD (LLIST GCD)
  389.  (MAPCAR #'(LAMBDA (X) (RPLACA X (QUOTIENT (CAR X) GCD))) LLIST)
  390.  LLIST)
  391.  
  392. (declare-top (SPLITFILE NTERMS))
  393.  
  394. (DEFMFUN $NTERMS (E)
  395.  (COND ((ZEROP1 E) 0)
  396.        ((ATOM E) 1)
  397.        ((EQ (CAAR E) 'MTIMES)
  398.     (IF (EQUAL -1 (CADR E)) (SETQ E (CDR E)))
  399.     (DO ((L (CDR E) (CDR L)) (C 1 (TIMES C ($NTERMS (CAR L)))))
  400.         ((NULL L) C)))
  401.        ((EQ (CAAR E) 'MPLUS)
  402.     (DO ((L (CDR E) (CDR L)) (C 0 (PLUS C ($NTERMS (CAR L)))))
  403.         ((NULL L) C)))
  404.        ((AND (EQ (CAAR E) 'MEXPT) (INTEGERP (CADDR E)) (PLUSP (CADDR E)))
  405.     ($BINOMIAL (PLUS (CADDR E) ($NTERMS (CADR E)) -1) (CADDR E)))
  406.        ((SPECREPP E) ($NTERMS (SPECDISREP E)))
  407.        (T 1)))
  408.  
  409.  
  410. ;;;; ATAN2
  411.  
  412. (DECLARE-TOP #-NIL (SPLITFILE ATAN2)
  413.      (SPECIAL $NUMER $%PIARGS $LOGARC $TRIGSIGN HALF%PI FOURTH%PI))
  414.  
  415. (DEFUN SIMPATAN2 (E VESTIGIAL Z)  ; atan2(y,x) ~ atan(y/x)
  416.  VESTIGIAL ;ignored
  417.  (TWOARGCHECK E)
  418.  (LET (Y X SIGN)
  419.       (SETQ Y (SIMPCHECK (CADR E) Z) X (SIMPCHECK (CADDR E) Z))
  420.       (COND ((AND (ZEROP1 Y) (ZEROP1 X))
  421.          (MERROR "ATAN2(0,0) has been generated."))
  422.         ((OR (AND (FLOATP Y) (FLOATP X))
  423.          (AND $NUMER (NUMBERP Y) (NUMBERP X)))
  424.          (ATAN2 Y X))
  425.         ((AND ($BFLOATP Y) ($BFLOATP X))
  426.          (IF (MMINUSP* Y) (NEG (*FPATAN (NEG Y) (LIST X)))
  427.                   (*FPATAN Y (LIST X))))
  428.         ((AND $%PIARGS (FREE X '$%I) (FREE Y '$%I)
  429.           (COND ((ZEROP1 Y) (IF (ATAN2NEGP X) (SIMPLIFY '$%PI) 0))
  430.             ((ZEROP1 X) 
  431.              (IF (ATAN2NEGP Y) (MUL2* -1 HALF%PI) (SIMPLIFY HALF%PI)))
  432.             ((ALIKE1 Y X)
  433.              (IF (ATAN2NEGP X) (MUL2* -3 FOURTH%PI) (SIMPLIFY FOURTH%PI)))
  434.             ((ALIKE1 Y (MUL2 -1 X))
  435.              (IF (ATAN2NEGP X) (MUL2* 3 FOURTH%PI) (MUL2* -1 FOURTH%PI)))
  436.             ((AND (EQUAL Y 1) (ALIKE1 X '((MEXPT SIMP) 3 ((RAT SIMP) 1 2))))
  437.              (MUL2* '((RAT SIMP) 1 6) '$%PI)))))
  438.         ($LOGARC (LOGARC '%ATAN (DIV Y X)))
  439.         ((AND $TRIGSIGN (MMINUSP* Y))
  440.          (NEG (SIMPLIFYA (LIST '($ATAN2) (NEG Y) X) T)))
  441.             ; atan2(y,x) = atan(y/x) + pi sign(y) (1-sign(x))/2
  442.         ((AND (FREE X '$%I) (EQ (SETQ SIGN ($SIGN X)) '$POS))
  443.          (SIMPLIFYA (LIST '(%ATAN) (DIV Y X)) T))
  444.         ((AND (EQ SIGN '$NEG) (FREE Y '$%I)
  445.           (MEMQ (SETQ SIGN ($SIGN Y)) '($POS $NEG)))
  446.          (ADD2 (SIMPLIFYA (LIST '(%ATAN) (DIV Y X)) T)
  447.            (PORM (EQ SIGN '$POS) (SIMPLIFY '$%PI))))
  448.         (T (EQTEST (LIST '($ATAN2) Y X) E)))))
  449.  
  450. (DEFUN ATAN2NEGP (E) (EQ (ASKSIGN-P-OR-N E) '$NEG))
  451.  
  452.  
  453. ;;;; ARITHF
  454.  
  455. (DECLARE-TOP #-NIL (SPLITFILE ARITHF)
  456.      (SPECIAL LNORECURSE))
  457.  
  458. (DEFMFUN $FIBTOPHI (E)
  459.  (COND ((ATOM E) E)
  460.        ((EQ (CAAR E) '$FIB)
  461.     (SETQ E (COND (LNORECURSE (CADR E)) (T ($FIBTOPHI (CADR E)))))
  462.     (LET ((PHI (MEVAL '$%PHI)))
  463.          (DIV (ADD2 (POWER PHI E) (NEG (POWER (ADD2 1 (NEG PHI)) E)))
  464.           (ADD2 -1 (MUL2 2 PHI)))))
  465.        (T (RECUR-APPLY #'$FIBTOPHI E))))
  466.  
  467. (DEFMSPEC $NUMERVAL (L) (SETQ L (CDR L))
  468.        (DO ((L L (CDDR L)) (X (NCONS '(MLIST SIMP)))) ((NULL L) X)
  469.        (COND ((NULL (CDR L)) (MERROR "NUMERVAL takes an even number of args"))
  470.          ((NOT (SYMBOLP (CAR L)))
  471.           (MERROR "~M must be atomic - NUMERVAL" (CAR L)))
  472.          ((BOUNDP (CAR L))
  473.           (MERROR "~M is bound - NUMERVAL" (CAR L))))
  474.        (MPUTPROP (CAR L) (CADR L) '$NUMER)
  475.        (ADD2LNC (CAR L) $PROPS)
  476.        (NCONC X (NCONS (CAR L)))))
  477.  
  478.  
  479. (declare-top (SPLITFILE DERIVD) (SPECIAL POWERS VAR DEPVAR))
  480.  
  481. (DEFMFUN $DERIVDEGREE (E DEPVAR VAR)
  482.  (LET (POWERS) (DERIVDEG1 E) (IF (NULL POWERS) 0 (MAXIMIN POWERS '$MAX))))
  483.  
  484. (DEFUN DERIVDEG1 (E)
  485.  (COND ((OR (ATOM E) (SPECREPP E)))
  486.        ((EQ (CAAR E) '%DERIVATIVE)
  487.     (COND ((ALIKE1 (CADR E) DEPVAR)
  488.            (DO ((L (CDDR E) (CDDR L))) ((NULL L))
  489.            (COND ((ALIKE1 (CAR L) VAR)
  490.               (RETURN (SETQ POWERS (CONS (CADR L) POWERS)))))))))
  491.        (T (MAPC 'DERIVDEG1 (CDR E)))))
  492.  
  493. (DECLARE-TOP (UNSPECIAL POWERS VAR DEPVAR))
  494.  
  495.  
  496. ;;;; BOX
  497.  
  498. (DECLARE-TOP #-NIL (SPLITFILE BOX)
  499.      )
  500.  
  501. (DEFMFUN $DPART N (MPART (LISTIFY N) NIL T NIL '$DPART))
  502.  
  503. (DEFMFUN $LPART N (MPART (CDR (LISTIFY N)) NIL (LIST (ARG 1)) NIL '$LPART))
  504.  
  505. (DEFMFUN $BOX N
  506.  (COND ((= N 1) (LIST '(MBOX) (ARG 1)))
  507.        ((= N 2) (LIST '(MLABOX) (ARG 1) (BOX-LABEL (ARG 2))))
  508.        (T (WNA-ERR '$BOX))))
  509.  
  510. (DEFMFUN BOX (E LABEL) (IF (EQ LABEL T) (LIST '(MBOX) E) ($BOX E (CAR LABEL))))
  511.  
  512. (DEFUN BOX-LABEL (X) (IF (ATOM X) X (IMPLODE (CONS #\& (MSTRING X)))))
  513.  
  514. (DECLARE-TOP (SPECIAL LABEL))
  515.  
  516. (DEFMFUN $REMBOX N
  517.  (LET ((LABEL (COND ((= N 1) '(NIL))
  518.             ((= N 2) (BOX-LABEL (ARG 2)))
  519.             (T (WNA-ERR '$REMBOX)))))
  520.       (REMBOX1 (ARG 1))))
  521.  
  522. (DEFUN REMBOX1 (E)
  523.  (COND ((ATOM E) E)
  524.        ((OR (AND (EQ (CAAR E) 'MBOX)
  525.          (OR (EQUAL LABEL '(NIL)) (MEMQ LABEL '($UNLABELLED $UNLABELED))))
  526.         (AND (EQ (CAAR E) 'MLABOX)
  527.          (OR (EQUAL LABEL '(NIL)) (EQUAL LABEL (CADDR E)))))
  528.     (REMBOX1 (CADR E)))
  529.        (T (RECUR-APPLY #'REMBOX1 E))))
  530.  
  531. (DECLARE-TOP (UNSPECIAL LABEL))
  532.  
  533.  
  534. ;;;; MAPF
  535.  
  536.  
  537. (declare-top #-NIL (SPLITFILE MAPF)
  538.      (SPECIAL SCANMAPP)
  539.      #-cl
  540.      (*LEXPR SCANMAP1))
  541.  
  542. (DEFMSPEC $SCANMAP (L)
  543.  (LET ((SCANMAPP T)) (RESIMPLIFY (APPLY #'SCANMAP1 (MMAPEV L)))))
  544.  
  545. (DEFMFUN SCANMAP1 N
  546.  (LET ((FUNC (ARG 1)) (ARG2 (SPECREPCHECK (ARG 2))) NEWARG2)
  547.    (COND ((EQ FUNC '$RAT) (MERROR "SCANMAP results must be in general representation."))
  548.      ((> N 2)
  549.       (COND ((EQ (ARG 3) '$BOTTOMUP)
  550.          (COND ((MAPATOM ARG2) (FUNCER FUNC (NCONS ARG2)))
  551.                (T (SUBST0 (FUNCER FUNC
  552.                       (NCONS (MCONS-OP-ARGS
  553.                           (MOP ARG2)
  554.                           (MAPCAR #'(LAMBDA (U)
  555.                                  (SCANMAP1
  556.                                   FUNC U '$BOTTOMUP))
  557.                               (MARGS ARG2)))))
  558.                   ARG2))))
  559.         ((> N 3) (WNA-ERR '$SCANMAP))
  560.         (T (MERROR "Only BOTTOMUP is an acceptable 3rd arg to SCANMAP."))))
  561.      ((MAPATOM ARG2) (FUNCER FUNC (NCONS ARG2)))
  562.      (T (SETQ NEWARG2 (SPECREPCHECK (FUNCER FUNC (NCONS ARG2))))
  563.         (COND ((MAPATOM NEWARG2) NEWARG2)
  564.           ((AND (ALIKE1 (CADR NEWARG2) ARG2) (NULL (CDDR NEWARG2)))
  565.            (SUBST0 (CONS (NCONS (CAAR NEWARG2))
  566.                  (NCONS (SUBST0 
  567.                      (MCONS-OP-ARGS
  568.                       (MOP ARG2)
  569.                       (MAPCAR #'(LAMBDA (U) (SCANMAP1 FUNC U))
  570.                           (MARGS ARG2)))
  571.                      ARG2)))
  572.                NEWARG2))
  573.           (T (SUBST0 (MCONS-OP-ARGS
  574.                   (MOP NEWARG2)
  575.                   (MAPCAR #'(LAMBDA (U) (SCANMAP1 FUNC U))
  576.                       (MARGS NEWARG2)))
  577.                  NEWARG2)))))))
  578.  
  579. (DEFUN SUBGEN (FORM)  ; This function does mapping of subscripts.
  580.  (DO ((DS (IF (EQ (CAAR FORM) 'MQAPPLY) (LIST (CAR FORM) (CADR FORM))
  581.                     (NCONS (CAR FORM)))
  582.       (OUTERMAP1 #'DSFUNC1 (SIMPLIFY (CAR SUB)) DS))
  583.       (SUB (REVERSE (OR (AND (EQ 'MQAPPLY (CAAR FORM)) (CDDR FORM))
  584.             (CDR FORM))) 
  585.        (CDR SUB)))
  586.      ((NULL SUB) DS)))
  587.  
  588. (DEFUN DSFUNC1 (DSN DSO)
  589.  (COND ((OR (ATOM DSO) (ATOM (CAR DSO))) DSO)
  590.        ((MEMQ 'array (CAR DSO))
  591.     (COND ((EQ 'MQAPPLY (CAAR DSO))
  592.            (NCONC (LIST (CAR DSO) (CADR DSO) DSN) (CDDR DSO)))
  593.           (T (NCONC (LIST (CAR DSO) DSN) (CDR DSO)))))
  594.        (T (MAPCAR #'(LAMBDA (D) (DSFUNC1 DSN D)) DSO))))
  595.  
  596.  
  597. ;;;; GENMAT
  598.  
  599. (DECLARE-TOP #-NIL (SPLITFILE GENMAT)
  600.      (FIXNUM DIM1 DIM2))
  601.  
  602. (DEFMFUN $GENMATRIX N
  603.  (LET ((ARGS (LISTIFY N)))
  604.       (IF (OR (< N 2) (> N 5)) (WNA-ERR '$GENMATRIX))
  605.       (IF (NOT (OR (SYMBOLP (CAR ARGS))
  606.            (HASH-TABLE-P (CAR ARGS))
  607.            (AND (NOT (ATOM (CAR ARGS)))
  608.             (EQ (CAAAR ARGS) 'LAMBDA))))
  609.       (IMPROPER-ARG-ERR (CAR ARGS) '$GENMATRIX))
  610.       ;(MEMQ NIL (MAPCAR #'(LAMBDA (U) (EQ (TYPEP U) 'FIXNUM)) (CDR ARGS)))
  611.       (IF (notevery #'fixnump (cdr args))
  612.       (MERROR "Invalid arguments to GENMATRIX:~%~M"
  613.           (CONS '(MLIST) (CDR ARGS))))
  614.       (LET* ((HEADER (LIST (CAR ARGS) 'array))
  615.          (DIM1 (CADR ARGS))
  616.          (DIM2 (IF (= N 2) (CADR ARGS) (CADDR ARGS)))
  617.          (I (IF (> N 3) (ARG 4) 1))
  618.          (J (IF (= N 5) (ARG 5) I))
  619.          (L (NCONS '($MATRIX))))
  620.         (COND ((AND (OR (= DIM1 0) (= DIM2 0)) (= I 1) (= J 1)))
  621.           ((OR (> I DIM1) (> J DIM2))
  622.            (MERROR "Invalid arguments to GENMATRIX:~%~M"
  623.                (CONS '(MLIST) ARGS))))
  624.         (DO ((I I (f1+ I))) ((> I DIM1)) (NCONC L (NCONS (NCONS '(MLIST)))))
  625.         (DO ((I I (f1+ I)) (L (CDR L) (CDR L))) ((> I DIM1))
  626.         (DO ((J J (f1+ J))) ((> J DIM2))
  627.             (NCONC (CAR L) (NCONS (MEVAL (LIST HEADER I J))))))
  628.         L)))
  629.  
  630. (DEFMFUN $COPYMATRIX (X)
  631.  (IF (NOT ($MATRIXP X)) (MERROR "Argument not a matrix - COPYMATRIX:~%~M" X))
  632.  (CONS (CAR X) (MAPCAR #'(LAMBDA (X) (copy-top-level X)) (CDR X))))
  633.  
  634. (DEFMFUN $COPYLIST (X)
  635.  (IF (NOT ($LISTP X)) (MERROR "Argument not a list - COPYLIST:~%~M" X))
  636.  (CONS (CAR X) (copy-top-level (CDR X))))
  637.  
  638.  
  639. ;;;; ADDROW
  640.  
  641. (DECLARE-TOP #-NIL (SPLITFILE ADDROW)
  642.      )
  643.  
  644. (DEFMFUN $ADDROW N
  645.  (COND ((= N 0) (WNA-ERR '$ADDROW))
  646.        ((NOT ($MATRIXP (ARG 1))) (MERROR "First argument to ADDROW must be a matrix"))
  647.        ((= N 1) (ARG 1))
  648.        (T (DO ((I 2 (f1+ I)) (M (ARG 1))) ((> I N) M)
  649.       (SETQ M (ADDROW M (ARG I)))))))
  650.  
  651. (DEFMFUN $ADDCOL N
  652.  (COND ((= N 0) (WNA-ERR '$ADDCOL))
  653.        ((NOT ($MATRIXP (ARG 1))) (MERROR "First argument to ADDCOL must be a matrix"))
  654.        ((= N 1) (ARG 1))
  655.        (T (DO ((I 2 (f1+ I)) (M ($TRANSPOSE (ARG 1)))) ((> I N) ($TRANSPOSE M))
  656.       (SETQ M (ADDROW M ($TRANSPOSE (ARG I))))))))
  657.  
  658. (DEFUN ADDROW (M R)
  659.  (COND ((NOT (MXORLISTP R)) (MERROR "Illegal argument to ADDROW or ADDCOL"))
  660.        ((AND (CDR M)
  661.          (OR (AND (EQ (CAAR R) 'MLIST) (NOT (= (LENGTH (CADR M)) (LENGTH R))))
  662.          (AND (EQ (CAAR R) '$MATRIX)
  663.               (NOT (= (LENGTH (CADR M)) (LENGTH (CADR R))))
  664.               (PROG2 (SETQ R ($TRANSPOSE R))
  665.                  (NOT (= (LENGTH (CADR M)) (LENGTH (CADR R))))))))
  666.     (MERROR "Incompatible structure - ADDROW//ADDCOL")))
  667.  (APPEND M (IF (EQ (CAAR R) '$MATRIX) (CDR R) (NCONS R))))
  668.  
  669.  
  670. ;;;; ARRAYF
  671.  
  672. (DECLARE-TOP #-NIL (SPLITFILE ARRAYF)
  673.      )
  674.  
  675. (DEFMFUN $ARRAYMAKE (ARY SUBS)
  676.  (COND ((OR (NOT ($LISTP SUBS)) (NULL (CDR SUBS)))
  677.     (MERROR "Wrong type argument to ARRAYMAKE:~%~M" SUBS))
  678.        ((EQ (ml-typep ARY) 'symbol)
  679.     (CONS (CONS (GETOPR ARY) '(ARRAY)) (CDR SUBS)))
  680.        (T (CONS '(MQAPPLY ARRAY) (CONS ARY (CDR SUBS))))))
  681.  
  682. ;(DEFMACRO $ARRAYINFO (ARY)
  683. ;  `(arrayinfo-aux ',ary (safe-value ,ary)))
  684.  
  685. (DEFMspec $ARRAYINFO (ary) (setq ary (cdr ary)) 
  686.   (arrayinfo-aux (car ary) (getvalue (car ary))))
  687.  
  688. (defun arrayinfo-aux (sym val)
  689.   (prog
  690.    (arra ary)
  691.    (setq arra  val)(setq ary sym)
  692.    (cond (arra
  693.       (cond
  694.         ((hash-table-p arra)
  695.          (let ((dim1 (gethash 'dim1 arra)))
  696.          (return
  697.           (list* '(mlist) '$hash_table (if dim1 1 t)
  698.              (sloop for (u v)
  699.                 in-table arra
  700.                 when (not (eq u 'dim1))
  701.                 collect
  702.                 (if (progn v dim1)  ;;ignore v
  703.                     u (cons '(mlist simp) u)))))))
  704.         ((arrayp arra)
  705.          (return
  706.           (let (dims)
  707.             (list '(mlist)
  708.               '$declared
  709.               ;; they don't want more info (array-type arra)
  710.               (length (setq dims (array-dimensions arra)))
  711.               (cons '(mlist) (mapcar #'1- dims))))))
  712.         ))
  713.      (t
  714.       (LET ((GEN (MGETL  sym '(HASHAR ARRAY))) ARY1)
  715.            (COND ((NULL GEN) (MERROR "Not an array - ARRAYINFO:~%~M" ARY))
  716.              ((MFILEP (CADR GEN))
  717.               (I-$UNSTORE (NCONS ARY))
  718.               (SETQ GEN (MGETL ARY '(HASHAR ARRAY)))))
  719.            (SETQ ARY1 (CADR GEN))
  720.            (COND ((EQ (CAR GEN) 'HASHAR)
  721.               #+cl (setq ary1 (symbol-array ary1))
  722.               (return
  723.                (APPEND '((MLIST SIMP) $HASHED)
  724.                    (CONS (aref ARY1 2)
  725.                      (DO ((I 3 (f1+ I)) (L)
  726.                       (N (CADR (ARRAYDIMS ARY1))))
  727.                      ((= I N) (SORT L
  728.                             #'(LAMBDA (X Y) (GREAT Y X))))
  729.                      (DO ((L1 (aref ARY1 I)
  730.                           (CDR L1))) ((NULL L1))
  731.                           (SETQ L (CONS
  732.                                (CONS
  733.                                 '(MLIST SIMP)
  734.                                 (CAAR L1))
  735.                                L))))))))
  736.              (T (SETQ ARY1 (ARRAYDIMS ARY1))
  737.             (return (LIST '(MLIST SIMP)
  738.                       (COND ((safe-GET ARY 'array)
  739.                          (CDR (ASSQ (CAR ARY1)
  740.                             '((T . $COMPLETE) (FIXNUM . $INTEGER)
  741.                               (FLONUM . $FLOAT)))))
  742.                         (T '$DECLARED))
  743.                       (LENGTH (CDR ARY1))
  744.                       (CONS '(MLIST SIMP) (MAPCAR #'1- (CDR ARY1))))))))))))
  745.  
  746.  
  747.  
  748.  
  749.  
  750.  
  751. ;(DEFMSPEC $ARRAYINFO (ARY) (SETQ ARY (CDR ARY))
  752. ;  (cond ($use_fast_arrays
  753. ;     (setq ary (symbol-value (car ary)))
  754. ;     (cond ((arrayp ary)
  755. ;        (let (dims)(list '(mlist) (array-type ary)
  756. ;                  (length (setq dims (array-dimensions ary)))
  757. ;                  (cons '(mlist) dims))))
  758. ;           (#-cl(ml-typep ary 'si:equal-hash-table )
  759. ;        #+cl (hash-table-p ary)
  760. ;        (list '(mlist) '$hash_table 1
  761. ;              (cons '(mlist)
  762. ;                (let (all-keys )
  763. ;                  (declare (special all-keys))
  764. ;                  (maphash #'(lambda (u v) 
  765. ;                       (declare (special all-keys)) v ;ignore
  766. ;                       (setq all-keys (cons u all-keys)))
  767. ;                       ary)
  768. ;                  all-keys))))
  769. ;           (t (fsignal "Use_fast_arrays is true and the argument of arrayinfo is not a hash-table or an array"))))
  770. ;    (t
  771. ;     (LET ((GEN (MGETL (SETQ ARY (CAR ARY)) '(HASHAR ARRAY))) ARY1)
  772. ;       (COND ((NULL GEN) (MERROR "Not an array - ARRAYINFO:~%~M" ARY))
  773. ;         ((MFILEP (CADR GEN))
  774. ;          (I-$UNSTORE (NCONS ARY))
  775. ;          (SETQ GEN (MGETL ARY '(HASHAR ARRAY)))))
  776. ;       (SETQ ARY1 (CADR GEN))
  777. ;       (COND ((EQ (CAR GEN) 'HASHAR)
  778. ;          (APPEND '((MLIST SIMP) $HASHED)
  779. ;              (CONS (FUNCALL ARY1 2)
  780. ;                (DO ((I 3 (f1+ I)) (L) (N (CADR (ARRAYDIMS ARY1))))
  781. ;                    ((= I N) (SORT L #'(LAMBDA (X Y) (GREAT Y X))))
  782. ;                  (DO L1 (FUNCALL ARY1 I) (CDR L1) (NULL L1)
  783. ;                      (SETQ L (CONS (CONS '(MLIST SIMP) (CAAR L1))
  784. ;                            L)))))))
  785. ;         (T (SETQ ARY1 (ARRAYDIMS ARY1))
  786. ;            (LIST '(MLIST SIMP)
  787. ;              (COND ((safe-GET ARY 'array)
  788. ;                 (CDR (ASSQ (CAR ARY1)
  789. ;                        '((T . $COMPLETE) (FIXNUM . $INTEGER)
  790. ;                          (FLONUM . $FLOAT)))))
  791. ;                (T '$DECLARED))
  792. ;              (LENGTH (CDR ARY1))
  793. ;              (CONS '(MLIST SIMP) (MAPCAR #'1- (CDR ARY1))))))))))
  794.  
  795.  
  796. ;;;; ALIAS
  797.  
  798. (DECLARE-TOP #-NIL (SPLITFILE ALIAS)
  799.      (SPECIAL ALIASLIST ALIASCNTR GREATORDER LESSORDER)
  800.      (FIXNUM ALIASCNTR))
  801.  
  802. (DEFMSPEC $MAKEATOMIC (L) (SETQ L (CDR L))
  803.  (DO ((L L (CDR L)) (BAS) (X)) ((NULL L) '$DONE)
  804.      (IF (OR (ATOM (CAR L))
  805.          (NOT (OR (SETQ X (MEMQ (CAAAR L) '(MEXPT MNCEXPT)))
  806.               (MEMQ 'array (CDAAR L)))))
  807.      (IMPROPER-ARG-ERR (CAR L) '$MAKEATOMIC))
  808.      (IF X (SETQ BAS (CADAR L) X (AND (ATOM (CADDAR L)) (CADDAR L)))
  809.        (SETQ BAS (CAAAR L) X (AND (ATOM (CADAR L)) (CADAR L))))
  810.      (IF (NOT (ATOM BAS)) (IMPROPER-ARG-ERR (CAR L) '$MAKEATOMIC))
  811.      (SETQ ALIASLIST
  812.        (CONS (CONS (CAR L)
  813.                (IMPLODE
  814.             (NCONC (EXPLODEN BAS)
  815.                    (OR (AND X (EXPLODEN X)) (NCONS '| |))
  816.                    (CONS '$ (MEXPLODEN (SETQ ALIASCNTR (f1+ ALIASCNTR)))))))
  817.          ALIASLIST))))
  818.  
  819. (DEFMSPEC $ORDERGREAT (L)
  820.   (IF GREATORDER (MERROR "Reordering is not allowed."))
  821.   (MAKORDER (SETQ GREATORDER (REVERSE (CDR L))) '_))
  822.  
  823. (DEFMSPEC $ORDERLESS (L)
  824.   (IF LESSORDER (MERROR "Reordering is not allowed."))
  825.   (MAKORDER (SETQ LESSORDER (CDR L)) '|#|))
  826.  
  827. (DEFUN MAKORDER (L CHAR)
  828.   (DO ((L L (CDR L)) (N 101 (f1+ N))) ((NULL L) '$DONE)
  829.     (ALIAS (CAR L)
  830.        (IMPLODE (NCONC (NCONS CHAR) (MEXPLODEN N)
  831.                (EXPLODEN (STRIPDOLLAR (CAR L))))))))
  832.  
  833. (DEFMFUN $UNORDER NIL
  834.  (LET ((L (DELQ NIL
  835.         (CONS '(MLIST SIMP)
  836.               (NCONC (mapcar #'(lambda (x) (remalias (getalias x)))
  837.                      lessorder)
  838.                  (mapcar #'(lambda (x) (remalias (getalias x)))
  839.                      greatorder))))))
  840.    (SETQ LESSORDER NIL GREATORDER NIL)
  841.    L))
  842.  
  843.  
  844. ;;;; CONCAT
  845.  
  846. (DECLARE-TOP #-NIL (SPLITFILE CONCAT)
  847.      (NOTYPE (ASCII-NUMBERP FIXNUM)))
  848.  
  849. (DEFMFUN $CONCAT (&REST L)
  850.   (IF (NULL L) (MERROR "CONCAT needs at least one argument."))
  851.   (IMPLODE
  852.    (CONS (COND ((NOT (ATOM (CAR L))))
  853.            ((OR (NUMBERP (CAR L)) (char= (GETCHARN (CAR L) 1) #\&)) #\&)
  854.            (T #\$))
  855.      (MAPCAN #'(LAMBDA (X)
  856.              (IF (NOT (ATOM X))
  857.              (MERROR "Argument to CONCAT not an atom: ~M" X))
  858.              (STRING* X))
  859.          L))))
  860.  
  861. (DEFMFUN $GETCHAR (X Y)
  862.  (LET ((N 0))
  863.       (COND ((NOT (SYMBOLP X))
  864.          (MERROR "1st argument to GETCHAR not a symbol: ~M" X))
  865.         ((OR (NOT (FIXNUMP Y)) (NOT (> Y 0)))
  866.          (MERROR "Incorrect 2nd argument to GETCHAR: ~M" Y))
  867. ;        ((char= (SETQ N (GETCHARN (FULLSTRIP1 X) Y)) 0) NIL)
  868.         ((char= (GETCHARN X 1) '#\&) (IMPLODE (LIST #\& N)))
  869.         ((ASCII-NUMBERP N) (f- (char-code N) (char-code #\0)))
  870.         (T (IMPLODE (LIST #\$ N))))))
  871.  
  872.  
  873. ;;;; ITS TTYINIT
  874.  
  875. #+ITS
  876. (DECLARE-TOP (SPLITFILE TTYINI)
  877.      (SPECIAL $PAGEPAUSE LINEL $LINEL SCROLLP TTYHEIGHT $PLOTHEIGHT
  878.           SMART-TTY RUBOUT-TTY 12-BIT-TTY CURSORPOS PLASMA-TTY
  879.           DISPLAY-FILE CHARACTER-GRAPHICS-TTY))
  880.  
  881. #+ITS
  882. (DEFMFUN $TTY_INIT NIL 
  883.   (SETQ $PAGEPAUSE (= 0 (BOOLE  BOOLE-AND (CADDR (STATUS TTY)) #. (f* 1 (^ 2 25.)))))
  884.         ; bit 3.8 (%TSMOR) of TTYSTS
  885.   (SETQ $LINEL (SETQ LINEL (LINEL T)))
  886.   (SETQ SCROLLP (NOT (= 0 (BOOLE  BOOLE-AND (CADDR (STATUS TTY)) #. (f* 1 (^ 2 30.))))))
  887.   (SETQ TTYHEIGHT (CAR (STATUS TTYSIZE))
  888.     $PLOTHEIGHT (IF (< TTYHEIGHT 200.) (f- TTYHEIGHT 2) 24.))
  889.   (LET ((TTYOPT (CAR (CDDDDR (SYSCALL 6 'CNSGET TYO)))))
  890.         ; %TOFCI (bit 3.4) = terminal has a 12 bit keyboard.
  891.     (SETQ 12-BIT-TTY (NOT (= (BOOLE  BOOLE-AND #. (f* 8 (^ 2 18.)) TTYOPT) 0)))
  892.         ; %TOMVU (bit 3.9) = terminal can do vertical cursor movement.
  893.         ; However, we must also make sure that the screen size
  894.         ; is within the ITS addressing limits.
  895.     (SETQ SMART-TTY (AND (NOT (= (BOOLE  BOOLE-AND #. (f* 256. (^ 2 18.)) TTYOPT) 0))
  896.              (< TTYHEIGHT 200.)
  897.              (< LINEL 128.)))
  898.         ; %TOERS (bit 4.6) = terminal can selectively erase.
  899.         ; %TOMVB (bit 4.4) = terminal can backspace.
  900.         ; %TOOVR (bit 4.1) = terminal can overstrike (i.e. printing one
  901.         ;              character on top of another causes both 
  902.         ;              to appear.)
  903.     (SETQ RUBOUT-TTY
  904.       (OR (NOT (= (BOOLE  BOOLE-AND #. (f* 32. (^ 2 27.)) TTYOPT) 0))      ;%TOERS
  905.           (AND (NOT (= (BOOLE  BOOLE-AND #. (f* 8. (^ 2 27.)) TTYOPT) 0))      ;%TOMVB
  906.            (= (BOOLE  BOOLE-AND #. (f* 1 (^ 2 27.)) TTYOPT) 0))))      ;%TOOVR
  907.         ; %TOCID (bit 3.1) = terminal can insert and delete characters.
  908.         ; If the console has a 12-bit keyboard, an 85 by 50 screen, and
  909.         ; can't ins/del characters, then it must be a Plasma console.
  910.     (SETQ PLASMA-TTY
  911.       (AND 12-BIT-TTY (= LINEL 84.) (= TTYHEIGHT 50.)
  912.            (= 0 (BOOLE  BOOLE-AND #. (f* 1 (^ 2 18.)) TTYOPT)))))
  913.   (SETQ CURSORPOS SMART-TTY)
  914.   (IF SMART-TTY (SETQ DISPLAY-FILE (OPEN '|TTY:| '(TTY OUT IMAGE BLOCK))))
  915.   (COND (PLASMA-TTY (LOAD '((DSK MACSYM) ARDS)))
  916.     ((OR (= TTY 13.) (JOB-EXISTS 'H19) (JOB-EXISTS 'H19WHO))
  917.      (LOAD '((DSK MACSYM) H19)))
  918.     ((JOB-EXISTS 'VT100) (LOAD '((DSK MACSYM) VT100)))
  919.     (T (SETQ CHARACTER-GRAPHICS-TTY NIL)
  920.        (REMPROP 'CG-D-PRODSIGN 'SUBR)
  921.        (REMPROP 'CG-D-SUMSIGN 'SUBR)))
  922.   '$DONE)
  923.  
  924. #+ITS
  925. (DEFUN JOB-EXISTS (JNAME) (PROBE-FILE (LIST '(USR *) (STATUS UNAME) JNAME)))
  926.  
  927.  
  928. ; Undeclarations for the file:
  929. #-NIL
  930. (DECLARE-TOP (NOTYPE N I J))
  931.